home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 1999 March - Disc 1 / Macworld (1999-03) (Disk 1).dmg / Shareware World / Utilities / Text Processing / Alpha / Tcl / Modes / diffMode.tcl < prev    next >
Encoding:
Text File  |  1998-12-06  |  29.7 KB  |  1,072 lines  |  [TEXT/ALFA]
  1. ## -*-Tcl-*-
  2.  # ###################################################################
  3.  #  Vince's Additions - an extension package for Alpha
  4.  # 
  5.  #  FILE: "diffMode.tcl"
  6.  #                                    created: 7/3/95 {11:15:02 pm} 
  7.  #                                last update: 6/12/1998 {12:21:19 am} 
  8.  #  Author: Vince Darley
  9.  #  E-mail: <darley@fas.harvard.edu>
  10.  #    mail: Division of Engineering and Applied Sciences, Harvard University
  11.  #          Oxford Street, Cambridge MA 02138, USA
  12.  #     www: <http://www.fas.harvard.edu/~darley/>
  13.  #  
  14.  # improvements Copyright (c) 1997-1998  Vince Darley, all rights reserved
  15.  # 
  16.  #  Description: 
  17.  #  
  18.  #  Largely re-written Diff mode for Alpha.  Still under construction,
  19.  #  but already a lot better than the old one.  Basic features:
  20.  #  
  21.  #  A 'Diff' menu, which contains commonly used options.
  22.  #  
  23.  #  Uses Alpha's 'marks' so that you can patch diffs back and forth
  24.  #  between files without losing the correct location in the file.
  25.  #  (previously if you modified one of the original windows, all line
  26.  #  numbers after that would be incorrect)
  27.  #  
  28.  #  Limitations:
  29.  #  
  30.  #  Sadly a lot of Alpha's window manipulation commands only work
  31.  #  on the foremost window.  This means this code is slowed down a
  32.  #  lot because it often has to bring a window to the front before
  33.  #  reading/writing into it.  There is a flag to setup a hack which
  34.  #  helps with this, at the expense of colours in the windows.
  35.  # 
  36.  #  History:
  37.  # 
  38.  #  modified by  rev reason
  39.  #  -------- --- --- -----------
  40.  #  7/3/95   Pete? 1.0 original
  41.  #  3/9/97   VMD 2.0 much improved version
  42.  #  03/23/98 VMD and Jon Guyer 2.0-3.0 various fixes and Voodoo 
  43.  # ###################################################################
  44.  ##
  45.  
  46. # Usage: diff [-#] [-abBcdefhHilnNprstTuvw] [-C lines] [-F regexp] [-I regexp]
  47. #        [-L label [-L label]] [-S file] [-D symbol] [+ignore-blank-lines]
  48. #        [+context[=lines]] [+unified[=lines]] [+ifdef=symbol]
  49. #        [+show-function-line=regexp]
  50. #        [+speed-large-files] [+ignore-matching-lines=regexp] [+new-file]
  51. #        [+initial-tab] [+starting-file=file] [+text] [+all-text] [+ascii]
  52. #        [+minimal] [+ignore-space-change] [+ed] [+reversed-ed] [+ignore-case]
  53. #        [+print] [+rcs] [+show-c-function] [+binary] [+brief] [+recursive]
  54. #        [+report-identical-files] [+expand-tabs] [+ignore-all-space]
  55. #        [+file-label=label [+file-label=label]] [+version] path1 path2
  56.  
  57. alpha::mode Diff 3.0b6 diffMenu {*.diff *.patch} {diffMenu} {
  58.     alpha::package require -loose Alpha 7.1p3
  59.     addMenu diffMenu •288
  60.     namespace eval compare {}
  61.     menu::insert Utils submenu 0 compare
  62.     menu::insert compare items end "windows" "files…" "directories…"
  63.     hook::register requireOpenWindowsHook [list compare windows] 2
  64.     ensureset DiffSig DIFF
  65.     set Diff::handlers(Diff-mode) Diff::runInsideAlpha
  66.     ensureset Diff::handler Diff-mode
  67.     # handler of Diff 
  68.     newPref var Diff::handler "Diff-mode" global "" Diff::handlers array
  69. } uninstall {
  70.     file delete "$pkg_file"
  71.     file delete [file join ${HOME} Tools "GNU Diff"]
  72. } maintainer {
  73.     "Vince Darley" darley@fas.harvard.edu <http://www.fas.harvard.edu/~darley/>
  74. } help {file "Diff Help"}
  75.  
  76. array set DiffAppSignatures {
  77.     GnuDiff DIFF
  78. }
  79. array set DiffAppScripts {
  80.     GnuDiff {
  81.     {dosc -c $quotedSig -s $flags}
  82.     }
  83. }
  84.  
  85. proc diffMenu {} {}
  86.  
  87. # Generally best to use this setting, but some actions can be a bit
  88. # slower with it on.  Allows you to patch changes back and forth
  89. # between windows automatically, which is otherwise not possible
  90. newPref f useSophisticatedDiffMarking 1 Diff
  91. # A good idea, but can mess up window colours sometimes
  92. # (it's a bit of a hack)
  93. newPref f useFastWindowSwapping 1 Diff
  94. # Slows things down in that it has to scan through Alpha's list of marks
  95. # to find the correct positions for each window, but speeds things up
  96. # because it doesn't need to activate each window in turn.  Try it and see
  97. # for yourself.
  98. newPref f useMarksDontBringToFront 1 Diff
  99. # Up/Down arrows both scroll the diff window and synchronise the viewed
  100. # portion of text in the document windows
  101. newPref f synchroniseMoveAndView 1 Diff Diff::bindUpDown
  102. # You'll probably want this; may slow things down a bit though
  103. newPref f workaroundAlphaColourBug 1 Diff
  104. # Default lines of context to generate when asking Diff to do its magic
  105. newPref var linesOfContext 3 Diff
  106. # Other diff flags you want to send (ignore whitespace etc)
  107. newPref var diffFlags { } Diff
  108. # If you've imported a diff file from a Unix system, this option allows
  109. # you to use it with Alpha too.
  110. newPref f convertSlashToColonInPaths 1 Diff
  111. # If you've imported a diff file from a different directory structure,
  112. # you may need to remove a given prefix so Alpha can find your files
  113. # correctly.
  114. newPref v removeFilePrefix "" Diff
  115.  
  116. Menu -n $diffMenu -p Diff::menuProc -M Diff {
  117.     "rerunDiff"
  118.     "(-"
  119.     "/<I<BpatchIntoLeftWindow"
  120.     "/<I<BpatchIntoRightWindow"
  121.     "(-"
  122.     "cleanUpAndCloseWindows"
  123.     "(-"
  124.     "locateLeftWindow"
  125.     "locateRightWindow"
  126.     "locateLeftDir"
  127.     "locateRightDir"
  128.     "parseDiffWin"
  129. }
  130. Bind 0x7b <z> Diff::patchIntoLeftWindow Diff
  131. Bind 0x7c <z> Diff::patchIntoRightWindow Diff
  132.  
  133. if {[info tclversion] < 8.0} {
  134.     # Bind manually due to bug
  135.     Bind 0x7b <oz> Diff::patchIntoLeftWindow Diff
  136.     Bind 0x7c <oz> Diff::patchIntoRightWindow Diff
  137. }
  138. # do the rest
  139. Bind '\r'        Diff::Select    Diff
  140. Bind '\t'        Diff::View    Diff
  141. Bind Kpad. <c>        Diff::Win
  142. Bind Enter        {Diff::Down;Diff::Select}    Diff
  143. Bind Kpad0        {Diff::Up;Diff::Select}    Diff
  144.  
  145. hook::register closeHook Diff::closing Diff
  146. hook::register openHook Diff::opening Diff
  147.  
  148. proc Diff::bindUpDown {} {
  149.     global DiffmodeVars
  150.     if $DiffmodeVars(synchroniseMoveAndView) {
  151.     catch {unBind down         Diff::Down Diff}
  152.     catch {unBind up         Diff::Up Diff}
  153.     Bind down        {Diff::Down;Diff::View}    Diff
  154.     Bind up        {Diff::Up;Diff::View}    Diff
  155.     } else {
  156.     catch {unBind down        {Diff::Down;Diff::View}    Diff}
  157.     catch {unBind up        {Diff::Up;Diff::View}    Diff}
  158.     Bind down         Diff::Down Diff
  159.     Bind up         Diff::Up Diff
  160.     }
  161. }
  162.  
  163. Diff::bindUpDown
  164.  
  165. proc Diff::menuProc {menu item} {
  166.     Diff::$item
  167. }
  168.  
  169. proc Diff::locateLeftWindow {} {
  170.     global Diff::1
  171.     set Diff::1 [getfile "Select your left (old) file:"]
  172.     Diff::Display Diff::1 1 0 1
  173.     Diff::setMarksUp
  174.     if [info exists Diff::1] {Diff::mark ${Diff::1} 1 ""}
  175.     Diff::diffWinFront
  176. }
  177.  
  178. proc Diff::locateRightWindow {} {
  179.     global Diff::2
  180.     set Diff::2 [getfile "Select your right (new) file:"]
  181.     Diff::Display Diff::2 0 0 1
  182.     Diff::setMarksUp
  183.     if [info exists Diff::2] {Diff::mark ${Diff::2} 0 ""}
  184.     Diff::diffWinFront
  185. }
  186.  
  187. proc Diff::locateLeftDir {} {
  188.     global Diff::leftDir
  189.     set Diff::leftDir [get_directory "Select your left (old) directory:"]
  190.     append Diff::leftDir :
  191. }
  192. proc Diff::locateRightDir {} {
  193.     global Diff::rightDir
  194.     set Diff::rightDir [get_directory "Select your right (new) directory:"]
  195.     append Diff::rightDir :
  196. }
  197.  
  198. proc Diff::rerunDiff {} {
  199.     global diffDir
  200.     Diff::diffWinFront
  201.     killWindow
  202.     if {$diffDir} {
  203.         Diff::execute 1 {* Directory Comparison *}
  204.     } else {
  205.         Diff::files
  206.     }
  207. }
  208.  
  209. proc Diff::cleanUpAndCloseWindows {} {
  210.     global Diff::1 Diff::2 diffDir
  211.     if ![catch {bringToFront ${Diff::1}}] {
  212.         removeAllMarks diff-*
  213.         shrinkFull
  214.         killWindow
  215.     }
  216.     
  217.     if ![catch {bringToFront ${Diff::2}}] {
  218.         removeAllMarks diff-*
  219.         shrinkFull
  220.         killWindow
  221.     }
  222.     Diff::diffWinFront
  223.     killWindow
  224. }
  225.  
  226. proc Diff::closing {{name ""}} {
  227.     global Diff::array Diff::Marked Diff::1 Diff::2
  228.     foreach var [info globals Diff::array*] {
  229.         global $var
  230.         if [array exists $var] { unset $var }
  231.     }
  232.     catch {unset Diff::Marked}
  233.     catch {unset Diff::1}
  234.     catch {unset Diff::2}
  235. }
  236.  
  237. ## 
  238.  # -------------------------------------------------------------------------
  239.  # 
  240.  # "Diff::opening" --
  241.  # 
  242.  #  This procedure is called whenever we open a diff window, whether 
  243.  #  a '.diff' file, or whether a window produced by this mode using
  244.  #  'Diff::execute'.  We parse its contents.
  245.  # -------------------------------------------------------------------------
  246.  ##
  247. proc Diff::opening {name} {
  248.     global Diff::window DiffmodeVars Diff::leftDir Diff::rightDir
  249.     set Diff::window $name
  250.     set Diff::leftDir ""
  251.     set Diff::rightDir ""
  252.     
  253.     if $DiffmodeVars(useSophisticatedDiffMarking) {
  254.         Diff::parseDiffWin
  255.     }
  256. }
  257.  
  258. # ◊◊◊◊ Parsing diff information ◊◊◊◊ #
  259.  
  260. proc Diff::parseDiffWin {} {
  261.     Diff::diffWinFront
  262.     global diffDir Diff::window
  263.     
  264.     set pos [minPos]
  265.     while 1 {
  266.     set res [search -s -n -f 1 -r 1 "^(diff.*|\[^- \n\r\]+)(\r|\n|\$)" $pos]
  267.     if {$res != ""} {
  268.         set pos [pos::math [lindex $res 0] + 1]
  269.         # if we picked up a 'diff...' line in a context diff
  270.         if {[lookAt $pos] == "i" && [lookAt [nextLineStart [lindex $res 0]]] == "*"} {
  271.         continue
  272.         }
  273.         set t [getText [lindex $res 0] [pos::math [lindex $res 1] - 1]]
  274.         if {[regexp {^\*+$} $t]} {
  275.         set diffDir 1
  276.         # check if the file has changed
  277.         if {[string index [set tt [getText [prevLineStart $pos] $pos]] 0] != " " \
  278.           && [lookAt [pos::math $pos - 3]] != "-" } {
  279.             set to [lindex $tt 1]
  280.             regexp " (.*)\t" $tt "" to
  281.             set p [prevLineStart $pos]
  282.             regexp " (.*)\t" [getText [prevLineStart $p] $p] from
  283.             regsub -all "/" $from ":" from
  284.             regsub -all "/" $to ":" to
  285.             lappend got [list "diff" $from $to]
  286.         }
  287.         set from [lindex [eval getText [search -s -n -f 1 -r 1 {^\*\*\* [0-9]+,[0-9]+} $pos]] 1]
  288.         set to [lindex [eval getText [search -s -n -f 1 -r 1 {^--- [0-9]+,[0-9]+} $pos]] 1]
  289.         lappend got "$from $to"
  290.         } else {
  291.         lappend got $t
  292.         }
  293.     } else {
  294.         break
  295.     }
  296.     }
  297.     set Diff::window [win::Current]
  298.     # now stored all diff items in the list 'got'
  299.     if [info exists got] {Diff::storeMarks $got}
  300.     Diff::diffWinFront
  301.     global tileTop tileWidth tileHeight tileLeft
  302.     set top [expr $tileTop + $tileHeight - 178]
  303.     sizeWin ${Diff::window} [expr $tileWidth - 6] 178
  304.     moveWin ${Diff::window} $tileLeft $top
  305.     
  306. }
  307.  
  308. proc Diff::storeMarks {diffs} {
  309.     global Diff::1 Diff::2 Diff::array
  310.     set suff ""
  311.     foreach m $diffs {
  312.     if [regexp {^diff} $m] {
  313.         set suff "/[file tail [lindex $m end]]"
  314.         global Diff::array${suff}
  315.         continue
  316.     }
  317.     set Diff::array${suff}($m) ""
  318.     }
  319. }
  320.  
  321. proc Diff::setMarksUp {{suff ""}} {
  322.     global Diff::array${suff}
  323.     foreach m [array names Diff::array$suff] {
  324.     set scanned [Diff::parseDiffString $m]
  325.     if {[scan $scanned "%s %d %d %d %d" \
  326.       char start1 end1 start2 end2] != 5} { error "Bad diff list!" }
  327.     if {$scanned != ""} {
  328.         set Diff::array${suff}($m) $scanned
  329.     }
  330.     }
  331. }
  332.  
  333. proc Diff::mark {win left {suff ""}} {
  334.     global Diff::array$suff DiffmodeVars
  335.     if {$win != ""} {
  336.         # Alpha somehow remembers the last mode in which it adjusts
  337.         # the window and so forgets all the colours if we cheat the
  338.         # mode switch.
  339.         if $DiffmodeVars(workaroundAlphaColourBug) {
  340.             bringToFront $win
  341.         } else {
  342.             Diff::BringToFront $win
  343.         }
  344.         # not strictly necessary, but cleaner
  345.         removeAllMarks diff-*
  346.         if $left {
  347.             foreach m [array names Diff::array$suff] {
  348.                 scan [set Diff::array${suff}($m)] "%s %d %d" char start1 end1
  349.                 setNamedMark "diff-$m" $start1 $start1 $end1
  350.             }
  351.         } else {
  352.             foreach m [array names Diff::array$suff] {
  353.                 scan [set Diff::array${suff}($m)] "%s %d %d %d %d" char start1 end1 start2 end2
  354.                 setNamedMark "diff-$m" $start2 $start2 $end2
  355.             }
  356.         }
  357.     }
  358. }
  359.  
  360. proc Diff::markUpWindow {diffs} {
  361.     alertnote "Currently a little obsolete; shouldn't be called!"
  362.     if [info exists Diff::1] {
  363.         Diff::BringToFront ${Diff::1}
  364.         # not strictly necessry, but cleaner
  365.         removeAllMarks diff-*
  366.         foreach m $diffs {
  367.             scan [set Diff::array($m)] "%s %d %d" char start1 end1
  368.             setNamedMark "diff-$m" $start1 $start1 $end1
  369.         }
  370.     }
  371.     if [info exists Diff::2] {
  372.         Diff::BringToFront ${Diff::2}
  373.         # not strictly necessry, but cleaner
  374.         removeAllMarks diff-*
  375.         foreach m $diffs {
  376.             scan [set Diff::array($m)] "%s %d %d %d %d" char start1 end1 start2 end2
  377.             setNamedMark "diff-$m" $start2 $start2 $end2
  378.         }
  379.     }
  380.     
  381. }
  382.  
  383. proc Diff::parseDiffString {text} {
  384.     global Diff::1 Diff::2
  385.     if {![regexp {[acd]} $text char]} {
  386.         # context sensitive
  387.         set char "c"
  388.         if {[scan $text "%d,%d %d,%d" one oned two twod] != 4} {
  389.             return
  390.         }
  391.     } else {
  392.         set res [split $text $char]
  393.         if {![scan [lindex $res 0] "%d,%d" one oned]} return
  394.         if {![scan [lindex $res 1] "%d,%d" two twod]} return
  395.         if ![info exists oned] { set oned $one }
  396.         if ![info exists twod] { set twod $two }
  397.     }
  398.     
  399.     if [info exists Diff::1] {
  400.         set res [list $char [rowColToPos -w ${Diff::1} $one 0]]
  401.         if {$char != "a"} {
  402.             lappend res [rowColToPos -w ${Diff::1} [expr $oned + 1] 0]
  403.         } else {
  404.             lappend res [rowColToPos -w ${Diff::1} $oned 1]
  405.         }
  406.     } else {
  407.         set res [list $char -1 -1]
  408.     }
  409.     
  410.     if [info exists Diff::2] {
  411.         lappend res [rowColToPos -w ${Diff::2} $two 0]
  412.         if {$char != "d"} {
  413.             lappend res [rowColToPos -w ${Diff::2} [expr $twod + 1] 0]]
  414.         } else {
  415.             lappend res [rowColToPos -w ${Diff::2} $twod 1]
  416.         }
  417.     } else {
  418.         lappend res -1 -1
  419.     }
  420.     return $res
  421. }
  422.  
  423. proc Diff::parseDiffLine {text {is_pos 0}} {
  424.     if {$is_pos} {
  425.         set text [Diff::line $text]
  426.     }
  427.     return [Diff::parseDiffString $text]
  428. }
  429.  
  430. proc Diff::line {pos {f ""}} {
  431.     global diffDir Diff::window DiffmodeVars
  432.     if $diffDir {
  433.         if {$f != ""} {upvar $f files}
  434.         if {[lookAt $pos] == "*" || [catch {search -s -f 0 -r 1 "^diff.*(\r|\n|\$)" $pos} res]} {
  435.             set p $pos
  436.             while 1 {
  437.                 set res [search -s -f 0 -r 1 "^\\*+(\r|\n|\$)" $p]
  438.                 set p [pos::math [lindex $res 0] - 2]
  439.                 if {[lookAt [lineStart $p]] != " " && [lookAt $p] != "-"} break
  440.             }
  441.             regexp " (.*)\t" [getText [lineStart $p] $p] "" to
  442.             regexp " (.*)\t" [getText [prevLineStart $p] [lineStart $p]] "" from
  443.             if {[set pr $DiffmodeVars(removeFilePrefix)] != ""} {
  444.                 regsub -all "/\./" $to "/" to
  445.                 if {[string first $pr $to] == 0} {
  446.                     set to [string range $to [string length $pr] end]
  447.                 }
  448.                 regsub -all "/\./" $from "/" from
  449.                 if {[string first $pr $from] == 0} {
  450.                     set from [string range $from [string length $pr] end]
  451.                 }
  452.             }
  453.             set files [list $from $to]
  454.             set tfrom [lindex [eval getText [search -s -n -f 1 -r 1 {^\*\*\* [0-9]+,[0-9]+} [getPos]]] 1]
  455.             set tto [lindex [eval getText [search -s -n -f 1 -r 1 {^--- [0-9]+,[0-9]+} [getPos]]] 1]
  456.             set text "$tfrom $tto"        
  457.         } else {
  458.             set llen [llength [set files [eval getText $res]]]
  459.             set files [lrange $files [expr $llen -2] end]
  460.             set text [getText [lineStart $pos] [expr [nextLineStart $pos] - 1]]
  461.         }
  462.         if $DiffmodeVars(convertSlashToColonInPaths) {
  463.             regsub -all "/" $files ":" files
  464.         }
  465.         set f [lindex $files end]
  466.         set suff "/[file tail $f]"
  467.     } else {
  468.         set suff ""
  469.         set text [getText [lineStart $pos] [pos::math [nextLineStart $pos] - 1]]
  470.     }
  471.     return "${text}${suff}"
  472. }
  473.  
  474. # ◊◊◊◊ Patching routines ◊◊◊◊ #
  475. proc Diff::patch {w1 w2 left} {
  476.     global DiffmodeVars
  477.     if {$DiffmodeVars(useSophisticatedDiffMarking)} {
  478.         Diff::patchSophisticated $w1 $w2 $left
  479.     } else {
  480.         Diff::patchOld $w1 $w2 $left
  481.     }
  482. }
  483. proc Diff::patchSophisticated {ww1 ww2 left} {
  484.     upvar \#0 $ww1 w1
  485.     upvar \#0 $ww2 w2
  486.     set code [Diff::line [getPos]]
  487.     regexp {([^/]+)(.*)} $code "" mark suff
  488.     global Diff::array${suff}
  489.     if ![info exists w1] { alpha::errorAlert "No such window" }
  490.     switch "[lindex [set Diff::array${suff}($mark)] 0]${left}" {
  491.         "c1" -
  492.         "c0" {
  493.             if [info exists w2] { 
  494.                 Diff::BringToFront ${w2}
  495.                 gotoMark "diff-$mark"
  496.                 set text [getSelect]
  497.             } else {
  498.                 # we assume the line is selected in the diff-win
  499.                 if $left {
  500.                     set p [selEnd]
  501.                     set e [search -s -f 1 -r 1 {^---.*$} $p]
  502.                     set p [lindex $e 1]
  503.                     set e [search -s -f 1 -r 1 {^[^>]} $p]
  504.                     set text [getText $p [lindex $e 0]]
  505.                     regsub -all "\[\n\r\]> " $text "\r" text
  506.                     set text [string range $text 1 end]
  507.                 } else {
  508.                     set p [selEnd]
  509.                     set e [search -s -f 1 -r 1 {^---} $p]
  510.                     set text [getText $p [lindex $e 0]]
  511.                     regsub -all "\[\r\n\]< " $text "\r" text
  512.                     set text [string range $text 1 end]
  513.                 }
  514.             }
  515.             Diff::BringToFront ${w1}
  516.             gotoMark "diff-$mark"
  517.             replaceText [getPos] [selEnd] $text
  518.         }
  519.         "d1" -
  520.         "a0" {
  521.             Diff::BringToFront ${w1}
  522.             gotoMark "diff-$mark"
  523.             deleteText [getPos] [selEnd]
  524.         }
  525.         "a1" -
  526.         "d0" {
  527.             if [info exists w2] { 
  528.                 Diff::BringToFront ${w2}
  529.                 gotoMark "diff-$mark"
  530.                 set text [getSelect]
  531.             } else {
  532.                 # we assume the line is selected in the diff-win
  533.                 if $left {
  534.                     set p [selEnd]
  535.                     set e [search -s -f 1 -r 1 {^---.*$} $p]
  536.                     set p [lindex $e 1]
  537.                     set e [search -s -f 1 -r 1 {^[^>]} $p]
  538.                     set text [getText $p [lindex $e 0]]
  539.                     regsub -all "\[\n\r\]> " $text "\r" text
  540.                     set text [string range $text 1 end]
  541.                 } else {
  542.                     set p [selEnd]
  543.                     set e [search -s -f 1 -r 1 {^---} $p]
  544.                     set text [getText $p [lindex $e 0]]
  545.                     regsub -all "\[\n\r\]< " $text "\r" text
  546.                     set text [string range $text 1 end]
  547.                 }
  548.             }
  549.             Diff::BringToFront ${w1}
  550.             gotoMark "diff-$mark"
  551.             nextLine
  552.             insertText -w ${w1} $text
  553.         }
  554.     }
  555.     Diff::diffWinFront
  556. }
  557. proc Diff::patchOld {ww1 ww2 left} {
  558.     upvar \#0 $ww1 w1
  559.     upvar \#0 $ww2 w2
  560.     set code [Diff::line [getPos]]
  561.     if {[scan [Diff::parseDiffLine $code] "%s %d %d %d %d" \
  562.         char start1 end1 start2 end2] != 5} { return }
  563.     
  564.     switch $char${left} {
  565.         "c1" {
  566.             set text [getText -w ${w2} $start2 $end2]
  567.             bringToFront ${w1}
  568.             replaceText $start1 $end1 $text
  569.         }
  570.         "d1" {
  571.             bringToFront ${w1}
  572.             deleteText $start1 $end1
  573.         }
  574.         "a1" {
  575.             set text [getText -w ${w2} $start2 $end2]
  576.             set p [nextLineStart $start1]
  577.             # for some reason this single line won't work instead of the
  578.             # next two!
  579.             #select -w ${Diff::1} $p $p
  580.             bringToFront ${w1}
  581.             goto $p
  582.             insertText -w ${w1} $text
  583.         }
  584.         "c0" {
  585.             set text [getText -w ${w2} $start1 $end1]
  586.             bringToFront ${w1}
  587.             replaceText $start2 $end2 $text
  588.         }
  589.         "d0" {
  590.             set text [getText -w ${w2} $start1 $end1]
  591.             bringToFront ${w1}
  592.             goto $start2
  593.             nextLine
  594.             insertText $text
  595.         }
  596.         "a0" {
  597.             bringToFront ${w1}
  598.             deleteText $start2 $end2
  599.         }
  600.     }
  601.     message "Subsequent insertions will be screwed up"
  602. }
  603.  
  604. # In the diff-window, 'c' = cut from left, replace with given lines,
  605. # 'd' = delete from left, 'a' = add to left.
  606. proc Diff::patchIntoLeftWindow {} {
  607.     Diff::patch Diff::1 Diff::2 1
  608. }
  609.  
  610. proc Diff::patchIntoRightWindow {} {
  611.     Diff::patch Diff::2 Diff::1 0
  612. }
  613.  
  614. # ◊◊◊◊ Main comparison routines ◊◊◊◊ #
  615.  
  616. proc Diff::files {} {
  617.     global Diff::1 Diff::2
  618.     foreach f [list ${Diff::1} ${Diff::2}] {
  619.         if {[lsearch [winNames -f] $f] >= 0} {
  620.             getWinInfo -w $f arr
  621.             if $arr(dirty) {
  622.                 bringToFront $f
  623.                 if {![dialog::yesno "Save this window?"]} { error "Cancel"}
  624.                 save
  625.             }
  626.         }
  627.     }
  628.     # make sure newer file is on the right
  629.     if [file::secondIsOlder ${Diff::1} ${Diff::2}] {
  630.         set d ${Diff::2}
  631.         set Diff::2 ${Diff::1}
  632.         set Diff::1 $d
  633.         unset d
  634.     }
  635.     Diff::run
  636. }
  637.  
  638. proc Diff::run {} {
  639.     global Diff::handler Diff::handlers
  640.     # call the registered procedure
  641.     [set Diff::handlers([set Diff::handler])]
  642. }
  643.  
  644. proc Diff::runInsideAlpha {} {
  645.     global Diff::1 Diff::2
  646.     Diff::Display Diff::1 1 0 1
  647.     Diff::Display Diff::2 0 0 1
  648.  
  649.     Diff::execute
  650. }
  651.  
  652. proc compare::directories {} {
  653.     global Diff::1 Diff::2
  654.     
  655.     set Diff::1 [get_directory -p "Select 'old' dir 1:"]
  656.     set Diff::2 [get_directory -p "Select 'new' dir 2:"]
  657.  
  658.     Diff::execute 1 {* Directory Comparison *}
  659. }
  660.  
  661. proc compare::files {} {
  662.     global Diff::1 Diff::2
  663.  
  664.     set Diff::1 [getfile "Select your 'old' file:"]
  665.     set Diff::2 [getfile "Select your 'new' file:"]
  666.     
  667.     Diff::files
  668. }
  669.  
  670. proc compare::windows {} {
  671.     global tileHeight tileWidth tileTop tileLeft
  672.     global Diff::1 Diff::2
  673.  
  674.     set wins [winNames -f]
  675.     if {[llength $wins] < 2} { message "Need 2 windows"; return }
  676.     
  677.     set Diff::1 [lindex $wins 0]
  678.     set Diff::2 [lindex $wins 1]
  679.     Diff::files
  680. }
  681.  
  682.  
  683. ## 
  684.  # -------------------------------------------------------------------------
  685.  # 
  686.  # "Diff::execute" --
  687.  # 
  688.  #  Modification of the original to optionally return the diff 
  689.  #  result, rather than opening it in a window
  690.  # 
  691.  # Results:
  692.  # 
  693.  #  Returns 1 if the files are the same and 0 if they differ
  694.  #  
  695.  #  If storeResult is true, the result of the diff operation is stored 
  696.  #  in the global Diff::result, rather than being opened in a window
  697.  # 
  698.  # --Version--Author------------------Changes-------------------------------
  699.  #    1.0     <keleher@cs.umd.edu> original
  700.  #    1.1     <j-guyer@nwu.edu> optionally return diff result in a global
  701.  #    1.2     <j-guyer@nwu.edu> flags set if files were open before compare
  702.  # -------------------------------------------------------------------------
  703.  ##
  704. proc Diff::execute {{isdir 0} {name {* File Comparison *}} {storeResult 0}} {
  705.     global DiffmodeVars \
  706.       Diff::1 Diff::2 win::Modes HOME diffDir Diff::result \
  707.       Diff::1Open Diff::2Open \
  708.       Diff::leftDir Diff::rightDir DiffSig
  709.  
  710.     set Diff::leftDir ""
  711.     set Diff::rightDir ""
  712.     set diffDir $isdir
  713.  
  714.     message "Launching 'GNU Diff'"
  715.     set flags $DiffmodeVars(diffFlags)
  716.     if {$DiffmodeVars(linesOfContext) != 0} {
  717.         append flags " -C $DiffmodeVars(linesOfContext)"
  718.     }
  719.     message "Starting diff…"
  720.     append flags " \"[stripNameCount ${Diff::1}]\" \"[stripNameCount ${Diff::2}]\""
  721.     set dtext [app::runScript Diff "Diff application" "" 1 0 $flags]
  722.     message "Starting diff…done"
  723.     
  724.     if {[lsearch [winNames -f] ${Diff::1}] >= 0} {
  725.         set Diff::1Open 1
  726.     } else {
  727.         set Diff::1Open 0
  728.     }
  729.     if {[lsearch [winNames -f] ${Diff::2}] >= 0} {
  730.         set Diff::2Open 1
  731.     } else {
  732.         set Diff::2Open 0
  733.     }
  734.  
  735.     if {![string length $dtext]} {
  736.         if {!$storeResult} {
  737.             alertnote    "No difference:\r${Diff::1}\r${Diff::2}"
  738.         }
  739.         return 0
  740.     } else {    
  741.         # If requested, return the diff result in Diff::result, 
  742.         # rather than opening a diff window
  743.         if {$storeResult} {
  744.             set Diff::result $dtext
  745.         } else {
  746.             Diff::diffWindow $dtext $name            
  747.         }
  748.         return 1
  749.     }
  750. }
  751.  
  752. proc Diff::displayAll {{name "* File Comparison *"}} {
  753.     global Diff::1 Diff::2 Diff::result
  754.     
  755.     Diff::Display Diff::1 1 0 1
  756.     Diff::Display Diff::2 0 0 1
  757.     Diff::diffWindow ${Diff::result} $name    
  758. }
  759.  
  760. proc Diff::diffWindow {diffText {name {* File Comparison *}}} {
  761.     global tileLeft tileTop tileWidth tileHeight    
  762.  
  763.     set top [expr $tileTop + $tileHeight - 178]
  764.     set n [new -n $name -g $tileLeft $top [expr $tileWidth - 6] 178 -m Diff]
  765.     insertText "\r$diffText\r"
  766.     winReadOnly
  767.     select [minPos] [nextLineStart [minPos]]
  768.     Diff::opening $n
  769. }
  770.  
  771. # ◊◊◊◊ Moving around ◊◊◊◊ #
  772. proc Diff::Up {} {
  773.     set res [search -s -f 0 -r 1 -- "^\[^- \n\r\]+(\r|\n|\$)" [pos::math [getPos] - 1]]
  774.     set pos [lindex $res 0]
  775.     select $pos [nextLineStart $pos]
  776.     display $pos
  777.     refresh
  778. }
  779.  
  780. proc Diff::Down {} {
  781.     set res [search -s -f 1 -r 1 -- "^\[^- \n\r\]+(\r|\n|\$)" [pos::math [getPos] + 1]]
  782.     set pos [lindex $res 0]
  783.     select $pos [nextLineStart $pos]    
  784.     display $pos
  785.     refresh
  786. }
  787.  
  788. proc Diff::Select {} {
  789.     global Diff::1 Diff::2 diffDir
  790.     
  791.     set text [getText [lineStart [getPos]] [pos::math [nextLineStart [getPos]] - 1]]
  792.     
  793.     if {![regexp {[acd]} $text char]} return
  794.     set res [split $text $char]
  795.     if {![scan [lindex $res 0] "%d" one]} return
  796.     if {![scan [lindex $res 1] "%d" two]} return
  797.     if {$one == 1} {incr one}
  798.     if {$two == 1} {incr two}
  799.  
  800.     if {$diffDir} {
  801.         set res [search -s -f 0 -r 1 "^diff.*(\r|\n|\$)" [getPos]]
  802.         set text [eval getText $res]
  803.         set len [llength $text]
  804.         set Diff::1 [lindex $text [expr $len - 2]]
  805.         set Diff::2 [lindex $text [expr $len - 1]]
  806.     }
  807.     Diff::Display Diff::1 1 [expr $one - 1] $diffDir
  808.     Diff::Display Diff::2 0 [expr $two - 1] $diffDir
  809.  
  810.     if {$diffDir} {
  811.         catch {bringToFront ${Diff::window}}
  812.     }
  813. }
  814.  
  815. proc Diff::Display {name left {row 0} {check 0}} {
  816.     upvar $name wname
  817.     if ![info exists wname] {
  818.         if $left {
  819.             message "Diff window for left doesn't exist"
  820.         } else {
  821.             message "Diff window for right doesn't exist"
  822.         }
  823.         return
  824.     }
  825.     if {$check} {
  826.         set geo [Diff::Geo $left]
  827.         set res [lsearch [winNames -f] "$wname"];
  828.         if { $res < 0 } {
  829.             set res [lsearch [winNames -f] "$wname <*>"];
  830.         }
  831.         if { $res < 0} {
  832.             eval edit -g $geo [list $wname]
  833.             set wname [win::Current]
  834.         } else {
  835.             set wname [lindex [winNames -f] $res]
  836.             if {[getGeometry $wname] != $geo} {
  837.                 sizeWin $wname [lindex $geo 2] [lindex $geo 3]
  838.                 moveWin $wname [lindex $geo 0] [lindex $geo 1]
  839.             }
  840.             if {$res > 2} {
  841.                 bringToFront $wname
  842.             }
  843.         }
  844.     }
  845.     display -w $wname [rowColToPos -w $wname $row 0]
  846. }
  847.  
  848. proc Diff::viewSophisticated {} {
  849.     global Diff::1 Diff::2 diffDir DiffmodeVars Diff::Marked
  850.     global Diff::leftDir Diff::rightDir
  851.     
  852.     set text [Diff::line [getPos] files]
  853.     
  854.     if {$diffDir} {
  855.     set Diff::1 ${Diff::leftDir}[lindex $files 0]
  856.     if ![file exists ${Diff::1}] {
  857.         if {${Diff::leftDir} == "" && ([set res [lsearch [winNames] "[file tail ${Diff::1}]*"]] != -1)} {
  858.         set Diff::1 [lindex [winNames -f] $res]
  859.         } else {
  860.         unset Diff::1
  861.         }
  862.     } else {
  863.         if {[set res [lsearch [winNames -f] "${Diff::1}*"]] != -1} {
  864.         set Diff::1 [lindex [winNames -f] $res]
  865.         }
  866.     }
  867.     set Diff::2 ${Diff::rightDir}[lindex $files 1]
  868.     if ![file exists ${Diff::2}] {
  869.         if {${Diff::rightDir} == "" && ([set res [lsearch [winNames] "[file tail ${Diff::2}]*"]] != -1)} {
  870.         set Diff::2 [lindex [winNames -f] $res]
  871.         } else {
  872.         unset Diff::2
  873.         }
  874.     } else {
  875.         if {[set res [lsearch [winNames -f] "${Diff::2}*"]] != -1} {
  876.         set Diff::2 [lindex [winNames -f] $res]
  877.         }
  878.     }
  879.     }
  880.     regexp {([^/]+)(.*)} $text "" mark suff
  881.     if ![info exists "Diff::Marked($suff)"] {
  882.     Diff::Display Diff::1 1 0 1
  883.     Diff::Display Diff::2 0 0 1
  884.     Diff::setMarksUp $suff
  885.     if [info exists Diff::1] {
  886.         Diff::mark ${Diff::1} 1 $suff
  887.         set Diff::Marked($suff) 1
  888.     }
  889.     if [info exists Diff::2] {
  890.         Diff::mark ${Diff::2} 0 $suff
  891.         set Diff::Marked($suff) 1
  892.     }
  893.     Diff::diffWinFront
  894.     }
  895.     set text $mark
  896.     
  897.     if $DiffmodeVars(useMarksDontBringToFront) {
  898.     if {![catch {tmark::getRange diff-$text ${Diff::1}} range]} {
  899.         set beg [lindex $range 0]
  900.         set end [lindex $range 2]
  901.         display -w ${Diff::1} [expr \
  902.           [pos::compare $beg > [minPos]] \
  903.           ? [pos::math $beg - 1] : $beg]
  904.         select -w ${Diff::1} $beg $end
  905.         if {[pos::compare $beg > [minPos]]} {
  906.         set beg [pos::math $beg - 1]
  907.         }
  908.         #display -w ${Diff::1} $beg
  909.         #refresh ${Diff::1}
  910.     }
  911.     
  912.     if {![catch {tmark::getRange diff-$text ${Diff::2}} range]} {
  913.         set beg [lindex $range 0]
  914.         set end [lindex $range 2]
  915.         display -w ${Diff::2} [expr \
  916.           [pos::compare $beg > [minPos]] \
  917.           ? [pos::math $beg - 1] : $beg]
  918.         select -w ${Diff::2} $beg $end
  919.         if {[pos::compare $beg > [minPos]]} {
  920.         set beg [pos::math $beg - 1]
  921.         }
  922.         #display -w ${Diff::2} $beg
  923.         #refresh ${Diff::2}
  924.     }
  925.     # we need this line because of an Alpha visual bug.
  926.     # Alpha will often draw the text in the wrong window when we 
  927.     # hit 'down'.  It does correct itself, but it looks silly.
  928.     Diff::diffWinFront
  929.     } else {            
  930.     if ![catch {Diff::BringToFront ${Diff::1}}] {
  931.         gotoMark "diff-$text"
  932.     }
  933.     if ![catch {Diff::BringToFront ${Diff::2}}] {
  934.         gotoMark "diff-$text"        
  935.     }
  936.     Diff::diffWinFront
  937.     }
  938. }
  939. proc Diff::viewOld {} {
  940.     global Diff::1 Diff::2 diffDir 
  941.     
  942.     set text [Diff::line [getPos]]
  943.     if {![regexp {[acd]} $text char]} return
  944.     set res [split $text $char]
  945.     if {![scan [lindex $res 0] "%d,%d" one oned]} return
  946.     if {![scan [lindex $res 1] "%d,%d" two twod]} return
  947.     set on $one
  948.     set tw $two
  949.     if {$on == 1} {incr on}
  950.     if {$tw == 1} {incr tw}
  951.     if {![info exists oned]} {set oned $one}
  952.     if {![info exists twod]} {set twod $two}
  953.  
  954.     if {$diffDir} {
  955.         set res [search -s -f 0 -r 1 "^diff.*(\r|\n|\$)" [getPos]]
  956.         set text [eval getText $res]
  957.         set Diff::1 [lindex $text 1]
  958.         set Diff::2 [lindex $text 2]
  959.     }
  960.     Diff::Sel Diff::1 [expr $on - 1] $one $oned 1
  961.     Diff::Sel Diff::2 [expr $tw - 1] $two $twod 0
  962.     set wins [lremove [lrange [winNames -f] 0 2] ${Diff::1} ${Diff::2}]
  963.     set wins [lremove -glob $wins *Comparison*]
  964.     if {$wins != ""} {
  965.         bringToFront ${Diff::1}
  966.         bringToFront ${Diff::2}
  967.     }
  968.     Diff::diffWinFront
  969. }
  970.  
  971. proc Diff::View {} {
  972.     global DiffmodeVars
  973.     if {$DiffmodeVars(useSophisticatedDiffMarking)} {
  974.         Diff::viewSophisticated
  975.     } else {
  976.         Diff::viewOld
  977.     }
  978. }
  979.  
  980. ## 
  981.  # -------------------------------------------------------------------------
  982.  # 
  983.  # "Diff::Sel" --
  984.  # 
  985.  #  This handles a name either with or without trailing '<n>' and fixes
  986.  #  the given name if it isn't right.
  987.  # -------------------------------------------------------------------------
  988.  ##
  989. proc Diff::Sel {wnamev ro row rowd left} {
  990.     global diffDir
  991.     upvar $wnamev wname
  992.     if {$diffDir} {
  993.         set geo [Diff::Geo $left]
  994.         if {[set res [lsearch [winNames -f] "$wname*"]] < 0} {
  995.             eval edit -g $geo [list $wname]
  996.             set wname [win::Current]
  997.         } else {
  998.             set wname [lindex [winNames -f] $res]
  999.             if {[getGeometry $wname] != $geo} {
  1000.                 sizeWin $wname [lindex $geo 2] [lindex $geo 3]
  1001.                 moveWin $wname [lindex $geo 0] [lindex $geo 1]
  1002.             }
  1003.         }
  1004.     }
  1005.     display -w $wname [rowColToPos -w $wname $ro 0]
  1006.     select -w $wname [rowColToPos -w $wname $row 0] [rowColToPos -w $wname [expr $rowd + 1] 0]
  1007. }
  1008.  
  1009. # ◊◊◊◊ Utilities ◊◊◊◊ #
  1010.  
  1011. proc Diff::Win {} {
  1012.     global win::Modes
  1013.     set files [winNames -f]
  1014.     set len [llength $files]
  1015.         for {set i 0} {$i < $len} {incr i} {
  1016.             if {[set win::Modes([lindex [winNames -f] $i])] == "Diff"} {
  1017.                 bringToFront [lindex [winNames] $i]
  1018.                 return
  1019.             }
  1020.         }
  1021.     beep
  1022.     message "No Diff window."
  1023. }
  1024.  
  1025. proc Diff::Geo {left} {
  1026.     global tileWidth tileHeight tileTop tileLeft
  1027.  
  1028.     set margin 4
  1029.     set width [expr ($tileWidth - $margin)/2]
  1030.     set height [expr $tileHeight - 200]
  1031.     set hor $tileLeft
  1032.  
  1033.     if {!$left} {incr hor [expr $width+$margin]}
  1034.     
  1035.     return [list $hor $tileTop $width $height]
  1036. }
  1037.  
  1038. proc Diff::diffWinFront {} {
  1039.     global Diff::window
  1040.     catch {bringToFront ${Diff::window}}
  1041. }
  1042.  
  1043. ## 
  1044.  # -------------------------------------------------------------------------
  1045.  # 
  1046.  # "Diff::BringToFront" --
  1047.  # 
  1048.  #  Hack to make it quicker to switch between windows.  We often want
  1049.  #  the 'Diff' window to be in the front all the time, but have to
  1050.  #  bring others to the front temporarily for manipulation.  This proc
  1051.  #  brings a different window to the front more quickly by avoiding
  1052.  #  all mode-changing code.  Of course you should only call this proc
  1053.  #  when you will _very_ soon bring a different window to the front.
  1054.  # -------------------------------------------------------------------------
  1055.  ##
  1056. proc Diff::BringToFront {w} {
  1057.     global win::Modes DiffmodeVars
  1058.     if $DiffmodeVars(useFastWindowSwapping) {
  1059.         set oldm [set win::Modes($w)]
  1060.         set win::Modes($w) Diff
  1061.         if [catch {bringToFront $w}] {
  1062.             unset win::Modes($w)
  1063.             beep
  1064.             error "no such win"
  1065.         } else {
  1066.             set win::Modes($w) $oldm
  1067.         }
  1068.     } else {
  1069.         bringToFront $w
  1070.     }
  1071. }
  1072.